nlcc report

import math
import sys

def polar_count(sequence):
    """
    This function counts the number of polar uncharged amino acids in the given sequence
    """
    [insert]
    return count

import math
import sys

def polar_count(sequence):
    """
    This function counts the number of polar uncharged amino acids in the given sequence
    """
    count = 0
    for amino_acid in sequence:
        if amino_acid in ['S', 'T', 'N', 'Q', 'H', 'K', 'R']:
            count += 1
    return count

sample_sequence = "AAAATTVVVVPPPSREREPPII"

result = True if polar_count(sample_sequence) == 3 else False

import math
import sys

def polar_count(sequence):
    """
    This function counts the number of polar uncharged amino acids in the given sequence
    """
    count = 0
    for i in sequence:
        if i == 'R' or i == 'K' or i == 'H' or i == 'D' or i == 'E' or i == 'S' or i == 'T' or i == 'N' or i == 'Q' or i == 'Y' or i == 'C' or i == 'M' or i == 'W':
            count += 1
    return count

sample_sequence = "AAAATTVVVVPPPSREREPPII"

result = True if polar_count(sample_sequence) == 3 else False

import math
import sys

def polar_count(sequence):
    """
    This function counts the number of polar uncharged amino acids in the given sequence
    """
    count = 0
    for i in sequence:
        if i == 'R' or i == 'K' or i == 'D' or i == 'E' or i == 'Q' or i == 'N' or i == 'H' or i == 'S' or i == 'T' or i == 'Y' or i == 'C' or i == 'M' or i == 'W':
            count += 1
    return count

sample_sequence = "AAAATTVVVVPPPSREREPPII"

result = True if polar_count(sample_sequence) == 3 else False

import math
import sys

def polar_count(sequence):
    """
    This function counts the number of polar uncharged amino acids in the given sequence
    """
    count = 0
    for i in sequence:
        if i == "S" or i == "T" or i == "N" or i == "Q" or i == "H" or i == "K" or i == "R":
            count += 1
    return count

sample_sequence = "AAAATTVVVVPPPSREREPPII"

result = True if polar_count(sample_sequence) == 3 else False

import math
import sys

def polar_count(sequence):
    """
    This function counts the number of polar uncharged amino acids in the given sequence
    """
    count = 0
    for i in sequence:
        if i == "R" or i == "K" or i == "E" or i == "D" or i == "Q" or i == "N" or i == "H" or i == "S" or i == "T" or i == "Y" or i == "C" or i == "M" or i == "W":
            count += 1
    return count

sample_sequence = "AAAATTVVVVPPPSREREPPII"

result = True if polar_count(sample_sequence) == 3 else False

import math
import sys

def cooling(T1,P1,P2,gamma):
   """
   This function returns the temperature of an ideal gas expanding adiabatically from P1 to P2
   """
   [insert]
   return T2

import math
import sys

def cooling(T1,P1,P2,gamma):
   """
   This function returns the temperature of an ideal gas expanding adiabatically from P1 to P2
   """
   T2 = T1*(P2/P1)**((gamma-1)/gamma)
   return T2

import numpy as np
P1 = 1
P2 = 2
T1 = 300
gamma = 5/3

T2 = T1*((P2/P1)**((gamma-1)/gamma))

T2_codex = cooling(T1, P1, P2, gamma)

# check 
if np.isclose(T2, T2_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def cooling(T1,P1,P2,gamma):
   """
   This function returns the temperature of an ideal gas expanding adiabatically from P1 to P2
   """
   T2 = T1*(P2/P1)**((gamma-1)/gamma)
   return T2

import numpy as np
P1 = 1
P2 = 2
T1 = 300
gamma = 5/3

T2 = T1*((P2/P1)**((gamma-1)/gamma))

T2_codex = cooling(T1, P1, P2, gamma)

# check 
if np.isclose(T2, T2_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def cooling(T1,P1,P2,gamma):
   """
   This function returns the temperature of an ideal gas expanding adiabatically from P1 to P2
   """
   T2 = T1*(P2/P1)**((gamma-1)/gamma)
   return T2

import numpy as np
P1 = 1
P2 = 2
T1 = 300
gamma = 5/3

T2 = T1*((P2/P1)**((gamma-1)/gamma))

T2_codex = cooling(T1, P1, P2, gamma)

# check 
if np.isclose(T2, T2_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def cooling(T1,P1,P2,gamma):
   """
   This function returns the temperature of an ideal gas expanding adiabatically from P1 to P2
   """
   T2 = T1*(P2/P1)**((gamma-1)/gamma)
   return T2

import numpy as np
P1 = 1
P2 = 2
T1 = 300
gamma = 5/3

T2 = T1*((P2/P1)**((gamma-1)/gamma))

T2_codex = cooling(T1, P1, P2, gamma)

# check 
if np.isclose(T2, T2_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def cooling(T1,P1,P2,gamma):
   """
   This function returns the temperature of an ideal gas expanding adiabatically from P1 to P2
   """
   T2 = T1*(P2/P1)**((gamma-1)/gamma)
   return T2

import numpy as np
P1 = 1
P2 = 2
T1 = 300
gamma = 5/3

T2 = T1*((P2/P1)**((gamma-1)/gamma))

T2_codex = cooling(T1, P1, P2, gamma)

# check 
if np.isclose(T2, T2_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import mdtraj as md
import numpy as np

def align_traj(traj, frame_index):
  """
  This function aligns the given mdtraj trajectory to a specific frame
  """
  [insert]
  return traj

import mdtraj as md
import numpy as np

def align_traj(traj, frame_index):
  """
  This function aligns the given mdtraj trajectory to a specific frame
  """
  traj.superpose(traj, frame=frame_index)
  return traj
import numpy as np
import sys
import os
import mdtraj as md

pdb_file = os.path.join(_FILE_DIR_, "1VII_twoframe_shifted.pdb")
trj = md.load(pdb_file)


def myrmsd(trj, frame):
    xyz = trj.xyz
    xyz0 = trj.xyz[frame]
    dx = xyz-xyz0
    dx2 = (dx*dx).sum(axis=2)
    rmsd = np.sqrt(dx2.mean(axis=1))
    return rmsd


#print("Starting rmsd:", myrmsd(trj, 0))
aligned_trj = trj.superpose(trj, 0)

my_rmsd = myrmsd(aligned_trj, 0)
#print("Aligned rmsd:", my_rmsd)

nlcc_trj = align_traj(trj, 0)
nlcc_rmsd = myrmsd(nlcc_trj, 0)

#print("nlcc rmsd", nlcc_rmsd)

result = True if np.all(np.abs(my_rmsd - nlcc_rmsd)) < 0.01 else False

import mdtraj as md
import numpy as np

def align_traj(traj, frame_index):
  """
  This function aligns the given mdtraj trajectory to a specific frame
  """
  traj.superpose(traj, frame=frame_index)
  return traj
import numpy as np
import sys
import os
import mdtraj as md

pdb_file = os.path.join(_FILE_DIR_, "1VII_twoframe_shifted.pdb")
trj = md.load(pdb_file)


def myrmsd(trj, frame):
    xyz = trj.xyz
    xyz0 = trj.xyz[frame]
    dx = xyz-xyz0
    dx2 = (dx*dx).sum(axis=2)
    rmsd = np.sqrt(dx2.mean(axis=1))
    return rmsd


#print("Starting rmsd:", myrmsd(trj, 0))
aligned_trj = trj.superpose(trj, 0)

my_rmsd = myrmsd(aligned_trj, 0)
#print("Aligned rmsd:", my_rmsd)

nlcc_trj = align_traj(trj, 0)
nlcc_rmsd = myrmsd(nlcc_trj, 0)

#print("nlcc rmsd", nlcc_rmsd)

result = True if np.all(np.abs(my_rmsd - nlcc_rmsd)) < 0.01 else False

import mdtraj as md
import numpy as np

def align_traj(traj, frame_index):
  """
  This function aligns the given mdtraj trajectory to a specific frame
  """
  traj.superpose(traj, frame=frame_index)
  return traj
import numpy as np
import sys
import os
import mdtraj as md

pdb_file = os.path.join(_FILE_DIR_, "1VII_twoframe_shifted.pdb")
trj = md.load(pdb_file)


def myrmsd(trj, frame):
    xyz = trj.xyz
    xyz0 = trj.xyz[frame]
    dx = xyz-xyz0
    dx2 = (dx*dx).sum(axis=2)
    rmsd = np.sqrt(dx2.mean(axis=1))
    return rmsd


#print("Starting rmsd:", myrmsd(trj, 0))
aligned_trj = trj.superpose(trj, 0)

my_rmsd = myrmsd(aligned_trj, 0)
#print("Aligned rmsd:", my_rmsd)

nlcc_trj = align_traj(trj, 0)
nlcc_rmsd = myrmsd(nlcc_trj, 0)

#print("nlcc rmsd", nlcc_rmsd)

result = True if np.all(np.abs(my_rmsd - nlcc_rmsd)) < 0.01 else False

import mdtraj as md
import numpy as np

def align_traj(traj, frame_index):
  """
  This function aligns the given mdtraj trajectory to a specific frame
  """
  traj.superpose(traj, frame=frame_index)
  return traj
import numpy as np
import sys
import os
import mdtraj as md

pdb_file = os.path.join(_FILE_DIR_, "1VII_twoframe_shifted.pdb")
trj = md.load(pdb_file)


def myrmsd(trj, frame):
    xyz = trj.xyz
    xyz0 = trj.xyz[frame]
    dx = xyz-xyz0
    dx2 = (dx*dx).sum(axis=2)
    rmsd = np.sqrt(dx2.mean(axis=1))
    return rmsd


#print("Starting rmsd:", myrmsd(trj, 0))
aligned_trj = trj.superpose(trj, 0)

my_rmsd = myrmsd(aligned_trj, 0)
#print("Aligned rmsd:", my_rmsd)

nlcc_trj = align_traj(trj, 0)
nlcc_rmsd = myrmsd(nlcc_trj, 0)

#print("nlcc rmsd", nlcc_rmsd)

result = True if np.all(np.abs(my_rmsd - nlcc_rmsd)) < 0.01 else False

import mdtraj as md
import numpy as np

def align_traj(traj, frame_index):
  """
  This function aligns the given mdtraj trajectory to a specific frame
  """
  traj.superpose(traj, frame=frame_index)
  return traj
import numpy as np
import sys
import os
import mdtraj as md

pdb_file = os.path.join(_FILE_DIR_, "1VII_twoframe_shifted.pdb")
trj = md.load(pdb_file)


def myrmsd(trj, frame):
    xyz = trj.xyz
    xyz0 = trj.xyz[frame]
    dx = xyz-xyz0
    dx2 = (dx*dx).sum(axis=2)
    rmsd = np.sqrt(dx2.mean(axis=1))
    return rmsd


#print("Starting rmsd:", myrmsd(trj, 0))
aligned_trj = trj.superpose(trj, 0)

my_rmsd = myrmsd(aligned_trj, 0)
#print("Aligned rmsd:", my_rmsd)

nlcc_trj = align_traj(trj, 0)
nlcc_rmsd = myrmsd(nlcc_trj, 0)

#print("nlcc rmsd", nlcc_rmsd)

result = True if np.all(np.abs(my_rmsd - nlcc_rmsd)) < 0.01 else False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def vector_angle(v1,v2):
    """
    This function returns the angle between vector v1 and vector v2.
    """
    [insert]
    return angle

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def vector_angle(v1,v2):
    """
    This function returns the angle between vector v1 and vector v2.
    """
    v1_u = v1 / np.linalg.norm(v1)
    v2_u = v2 / np.linalg.norm(v2)
    angle = np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))
    return angle
import numpy as np

def unit_vec(vector):
    return vector / np.linalg.norm(vector)

v1 =  [1.2,0.5,0.5]
v2 =  [-1.5,2.0,0.0]

v1_u = unit_vec(v1)
v2_u = unit_vec(v2)

angle = np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))

angle_codex =  vector_angle(v1,v2)

if np.isclose(angle, angle_codex) == True:
    result = True
else:
    result = False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def vector_angle(v1,v2):
    """
    This function returns the angle between vector v1 and vector v2.
    """
    v1_u = v1 / np.linalg.norm(v1)
    v2_u = v2 / np.linalg.norm(v2)
    angle = np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))
    return angle
import numpy as np

def unit_vec(vector):
    return vector / np.linalg.norm(vector)

v1 =  [1.2,0.5,0.5]
v2 =  [-1.5,2.0,0.0]

v1_u = unit_vec(v1)
v2_u = unit_vec(v2)

angle = np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))

angle_codex =  vector_angle(v1,v2)

if np.isclose(angle, angle_codex) == True:
    result = True
else:
    result = False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def vector_angle(v1,v2):
    """
    This function returns the angle between vector v1 and vector v2.
    """
    v1 = np.array(v1)
    v2 = np.array(v2)
    v1_u = v1/np.linalg.norm(v1)
    v2_u = v2/np.linalg.norm(v2)
    angle = np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))
    return angle
import numpy as np

def unit_vec(vector):
    return vector / np.linalg.norm(vector)

v1 =  [1.2,0.5,0.5]
v2 =  [-1.5,2.0,0.0]

v1_u = unit_vec(v1)
v2_u = unit_vec(v2)

angle = np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))

angle_codex =  vector_angle(v1,v2)

if np.isclose(angle, angle_codex) == True:
    result = True
else:
    result = False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def vector_angle(v1,v2):
    """
    This function returns the angle between vector v1 and vector v2.
    """
    v1_u = v1/np.linalg.norm(v1)
    v2_u = v2/np.linalg.norm(v2)
    angle = np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))
    if np.isnan(angle):
        if (v1_u == v2_u).all():
            return 0.0
        else:
            return np.pi
    return angle


    return angle
import numpy as np

def unit_vec(vector):
    return vector / np.linalg.norm(vector)

v1 =  [1.2,0.5,0.5]
v2 =  [-1.5,2.0,0.0]

v1_u = unit_vec(v1)
v2_u = unit_vec(v2)

angle = np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))

angle_codex =  vector_angle(v1,v2)

if np.isclose(angle, angle_codex) == True:
    result = True
else:
    result = False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def vector_angle(v1,v2):
    """
    This function returns the angle between vector v1 and vector v2.
    """
    cosang = np.dot(v1,v2)
    sinang = np.linalg.norm(np.cross(v1,v2))
    angle = np.arctan2(sinang,cosang)
    return angle
import numpy as np

def unit_vec(vector):
    return vector / np.linalg.norm(vector)

v1 =  [1.2,0.5,0.5]
v2 =  [-1.5,2.0,0.0]

v1_u = unit_vec(v1)
v2_u = unit_vec(v2)

angle = np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0))

angle_codex =  vector_angle(v1,v2)

if np.isclose(angle, angle_codex) == True:
    result = True
else:
    result = False

import math
import sys

def aromatic_aa(sequence):
    """
    This function takes in an amino acid sequence and returns the number of aromatic residues there are
    """
    [insert]
    return count

import math
import sys

def aromatic_aa(sequence):
    """
    This function takes in an amino acid sequence and returns the number of aromatic residues there are
    """
    aromatic = ['F', 'Y', 'W']
    count = 0
    for i in sequence:
        if i in aromatic:
            count += 1
    return count

result = True if aromatic_aa("FLRYSCV")==2 else False

import math
import sys

def aromatic_aa(sequence):
    """
    This function takes in an amino acid sequence and returns the number of aromatic residues there are
    """
    count = 0
    for i in sequence:
        if i == 'F' or i == 'Y' or i == 'W':
            count += 1
    return count

result = True if aromatic_aa("FLRYSCV")==2 else False

import math
import sys

def aromatic_aa(sequence):
    """
    This function takes in an amino acid sequence and returns the number of aromatic residues there are
    """
    aromatic_list = ['F', 'Y', 'W']
    count = 0
    for aa in sequence:
        if aa in aromatic_list:
            count += 1
    return count

result = True if aromatic_aa("FLRYSCV")==2 else False

import math
import sys

def aromatic_aa(sequence):
    """
    This function takes in an amino acid sequence and returns the number of aromatic residues there are
    """
    count = 0
    for aa in sequence:
        if aa == 'F' or aa == 'Y' or aa == 'W':
            count += 1
    return count

result = True if aromatic_aa("FLRYSCV")==2 else False

import math
import sys

def aromatic_aa(sequence):
    """
    This function takes in an amino acid sequence and returns the number of aromatic residues there are
    """
    count = 0
    for aa in sequence:
        if aa == 'F' or aa == 'Y' or aa == 'W':
            count += 1
    return count

result = True if aromatic_aa("FLRYSCV")==2 else False

import math
import sys

def arrhenius(k2,T2,T1,Ea):
   """
   This function returns the value of the rate constant at temperature T1 using the Arrhenius equation
   k2 is the rate constant at temperature T2.
   Ea is the activation energy in J/mol.
   Temperatures are given in Kelvin
   """
   [insert]
   return k1

import math
import sys

def arrhenius(k2,T2,T1,Ea):
   """
   This function returns the value of the rate constant at temperature T1 using the Arrhenius equation
   k2 is the rate constant at temperature T2.
   Ea is the activation energy in J/mol.
   Temperatures are given in Kelvin
   """
   k1 = k2*math.exp((-Ea)/(8.314*T1))
   return k1
import numpy as np

# inputs
T1 = 308.18   # in K
T2 = 333.18   # in K
R = 8.314     # J/mol.K
Ea = 108000   # J/mol
k2 = 1e-3     # M-1 s-1 

k1 = k2*np.exp((-Ea/R) * (1/T1 - 1/T2))
k1_codex = arrhenius(k2,T2,T1,Ea)
#print(k1,k1_codex)

if np.isclose(k1,k1_codex) == True:
    result = True
else:
    result = False

import math
import sys

def arrhenius(k2,T2,T1,Ea):
   """
   This function returns the value of the rate constant at temperature T1 using the Arrhenius equation
   k2 is the rate constant at temperature T2.
   Ea is the activation energy in J/mol.
   Temperatures are given in Kelvin
   """
   k1 = k2*math.exp((-Ea/8.314)*((1/T1)-(1/T2)))
   return k1
import numpy as np

# inputs
T1 = 308.18   # in K
T2 = 333.18   # in K
R = 8.314     # J/mol.K
Ea = 108000   # J/mol
k2 = 1e-3     # M-1 s-1 

k1 = k2*np.exp((-Ea/R) * (1/T1 - 1/T2))
k1_codex = arrhenius(k2,T2,T1,Ea)
#print(k1,k1_codex)

if np.isclose(k1,k1_codex) == True:
    result = True
else:
    result = False

import math
import sys

def arrhenius(k2,T2,T1,Ea):
   """
   This function returns the value of the rate constant at temperature T1 using the Arrhenius equation
   k2 is the rate constant at temperature T2.
   Ea is the activation energy in J/mol.
   Temperatures are given in Kelvin
   """
   k1 = k2 * math.exp((Ea/8.314)*((1/T2)-(1/T1)))
   return k1
import numpy as np

# inputs
T1 = 308.18   # in K
T2 = 333.18   # in K
R = 8.314     # J/mol.K
Ea = 108000   # J/mol
k2 = 1e-3     # M-1 s-1 

k1 = k2*np.exp((-Ea/R) * (1/T1 - 1/T2))
k1_codex = arrhenius(k2,T2,T1,Ea)
#print(k1,k1_codex)

if np.isclose(k1,k1_codex) == True:
    result = True
else:
    result = False

import math
import sys

def arrhenius(k2,T2,T1,Ea):
   """
   This function returns the value of the rate constant at temperature T1 using the Arrhenius equation
   k2 is the rate constant at temperature T2.
   Ea is the activation energy in J/mol.
   Temperatures are given in Kelvin
   """
   k1 = k2*math.exp((Ea/8.314)*((1/T2)-(1/T1)))
   return k1
import numpy as np

# inputs
T1 = 308.18   # in K
T2 = 333.18   # in K
R = 8.314     # J/mol.K
Ea = 108000   # J/mol
k2 = 1e-3     # M-1 s-1 

k1 = k2*np.exp((-Ea/R) * (1/T1 - 1/T2))
k1_codex = arrhenius(k2,T2,T1,Ea)
#print(k1,k1_codex)

if np.isclose(k1,k1_codex) == True:
    result = True
else:
    result = False

import math
import sys

def arrhenius(k2,T2,T1,Ea):
   """
   This function returns the value of the rate constant at temperature T1 using the Arrhenius equation
   k2 is the rate constant at temperature T2.
   Ea is the activation energy in J/mol.
   Temperatures are given in Kelvin
   """
   k1 = k2*math.exp((Ea/8.314)*((1/T1)-(1/T2)))
   return k1
import numpy as np

# inputs
T1 = 308.18   # in K
T2 = 333.18   # in K
R = 8.314     # J/mol.K
Ea = 108000   # J/mol
k2 = 1e-3     # M-1 s-1 

k1 = k2*np.exp((-Ea/R) * (1/T1 - 1/T2))
k1_codex = arrhenius(k2,T2,T1,Ea)
#print(k1,k1_codex)

if np.isclose(k1,k1_codex) == True:
    result = True
else:
    result = False

import math
import sys

def bimolecular_rate(k,A,B):
   """
   This function returns the rate of reaction given the rate constant k and concentrations of species A and B
   """
   [insert]
   return rate

import math
import sys

def bimolecular_rate(k,A,B):
   """
   This function returns the rate of reaction given the rate constant k and concentrations of species A and B
   """
   rate = k*A*B
   return rate
import numpy as np

k = 2
A = 0.1
B = 0.2
rate = k*A*B

result = True if np.isclose(rate,bimolecular_rate(k,A,B)) else False

import math
import sys

def bimolecular_rate(k,A,B):
   """
   This function returns the rate of reaction given the rate constant k and concentrations of species A and B
   """
   rate = k*A*B
   return rate
import numpy as np

k = 2
A = 0.1
B = 0.2
rate = k*A*B

result = True if np.isclose(rate,bimolecular_rate(k,A,B)) else False

import math
import sys

def bimolecular_rate(k,A,B):
   """
   This function returns the rate of reaction given the rate constant k and concentrations of species A and B
   """
   rate = k*A*B
   return rate
import numpy as np

k = 2
A = 0.1
B = 0.2
rate = k*A*B

result = True if np.isclose(rate,bimolecular_rate(k,A,B)) else False

import math
import sys

def bimolecular_rate(k,A,B):
   """
   This function returns the rate of reaction given the rate constant k and concentrations of species A and B
   """
   rate = k*A*B
   return rate
import numpy as np

k = 2
A = 0.1
B = 0.2
rate = k*A*B

result = True if np.isclose(rate,bimolecular_rate(k,A,B)) else False

import math
import sys

def bimolecular_rate(k,A,B):
   """
   This function returns the rate of reaction given the rate constant k and concentrations of species A and B
   """
   rate = k*A*B
   return rate
import numpy as np

k = 2
A = 0.1
B = 0.2
rate = k*A*B

result = True if np.isclose(rate,bimolecular_rate(k,A,B)) else False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def bb_radiation(lam, T):
   """
   This function calculates and returns the spectral radiance value in SI unit for wavelength lam at temperature T, using planck's law of black body radiation.
   """
   [insert]
   return B

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def bb_radiation(lam, T):
   """
   This function calculates and returns the spectral radiance value in SI unit for wavelength lam at temperature T, using planck's law of black body radiation.
   """
   c1 = 3.74177e-16
   c2 = 1.4388e-2
   B = c1/(lam**5 * (np.exp(c2/(lam*T)) - 1))
   return B
import numpy as np
import matplotlib.pyplot as plt

# input params
h = 6.634e-34       # J.s
c = 3.0e8           # m/s
k = 1.381e-23       # J.K-1
T = 5000            # in K
lamb_val = 1.0e-6   # in m


# spectral radiance
B = (2*h*c**2/lamb_val**5) * (1/(np.exp(h*c/(lamb_val*k*T)) - 1))
print("spectral radiance =", B)

B_codex = bb_radiation(lamb_val, T)
print("spectral radiance from codex =", B_codex)


# check
if abs((B - B_codex) / B) <= 1e-2:
    result = True
else:
    result = False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def bb_radiation(lam, T):
   """
   This function calculates and returns the spectral radiance value in SI unit for wavelength lam at temperature T, using planck's law of black body radiation.
   """
   h = 6.626e-34
   c = 3e8
   k = 1.38e-23
   B = 2*h*c**2/lam**5/(np.exp(h*c/(lam*k*T))-1)
   return B
import numpy as np
import matplotlib.pyplot as plt

# input params
h = 6.634e-34       # J.s
c = 3.0e8           # m/s
k = 1.381e-23       # J.K-1
T = 5000            # in K
lamb_val = 1.0e-6   # in m


# spectral radiance
B = (2*h*c**2/lamb_val**5) * (1/(np.exp(h*c/(lamb_val*k*T)) - 1))
print("spectral radiance =", B)

B_codex = bb_radiation(lamb_val, T)
print("spectral radiance from codex =", B_codex)


# check
if abs((B - B_codex) / B) <= 1e-2:
    result = True
else:
    result = False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def bb_radiation(lam, T):
   """
   This function calculates and returns the spectral radiance value in SI unit for wavelength lam at temperature T, using planck's law of black body radiation.
   """
   h = 6.62607004e-34
   c = 3.0e8
   k = 1.38064852e-23
   B = 2*h*c**2/(lam**5)*1/(np.exp(h*c/(lam*k*T))-1)
   return B
import numpy as np
import matplotlib.pyplot as plt

# input params
h = 6.634e-34       # J.s
c = 3.0e8           # m/s
k = 1.381e-23       # J.K-1
T = 5000            # in K
lamb_val = 1.0e-6   # in m


# spectral radiance
B = (2*h*c**2/lamb_val**5) * (1/(np.exp(h*c/(lamb_val*k*T)) - 1))
print("spectral radiance =", B)

B_codex = bb_radiation(lamb_val, T)
print("spectral radiance from codex =", B_codex)


# check
if abs((B - B_codex) / B) <= 1e-2:
    result = True
else:
    result = False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def bb_radiation(lam, T):
   """
   This function calculates and returns the spectral radiance value in SI unit for wavelength lam at temperature T, using planck's law of black body radiation.
   """
   h = 6.626e-34
   c = 3e8
   k = 1.38e-23
   B = (2*h*c**2)/(lam**5*(np.exp((h*c)/(lam*k*T))-1))
   return B
import numpy as np
import matplotlib.pyplot as plt

# input params
h = 6.634e-34       # J.s
c = 3.0e8           # m/s
k = 1.381e-23       # J.K-1
T = 5000            # in K
lamb_val = 1.0e-6   # in m


# spectral radiance
B = (2*h*c**2/lamb_val**5) * (1/(np.exp(h*c/(lamb_val*k*T)) - 1))
print("spectral radiance =", B)

B_codex = bb_radiation(lamb_val, T)
print("spectral radiance from codex =", B_codex)


# check
if abs((B - B_codex) / B) <= 1e-2:
    result = True
else:
    result = False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def bb_radiation(lam, T):
   """
   This function calculates and returns the spectral radiance value in SI unit for wavelength lam at temperature T, using planck's law of black body radiation.
   """
   h = 6.626e-34
   c = 3e8
   k = 1.38e-23
   B = 2*h*c**2/lam**5/(np.exp(h*c/(lam*k*T))-1)
   return B
import numpy as np
import matplotlib.pyplot as plt

# input params
h = 6.634e-34       # J.s
c = 3.0e8           # m/s
k = 1.381e-23       # J.K-1
T = 5000            # in K
lamb_val = 1.0e-6   # in m


# spectral radiance
B = (2*h*c**2/lamb_val**5) * (1/(np.exp(h*c/(lamb_val*k*T)) - 1))
print("spectral radiance =", B)

B_codex = bb_radiation(lamb_val, T)
print("spectral radiance from codex =", B_codex)


# check
if abs((B - B_codex) / B) <= 1e-2:
    result = True
else:
    result = False

import requests
from bs4 import BeautifulSoup
import numpy as np

def blast(seq):
    '''
    Returns MSA with a BLAST search. Uses beautiful soup
    to parse result.

    1. import packages
    2. Submit BLAST search with sequences
    3. Get result
    4. Parse MSA
    5. Return a tuple of e score, id of top match
    '''
    [insert]
    return e, id

import requests
from bs4 import BeautifulSoup
import numpy as np

def blast(seq):
    '''
    Returns MSA with a BLAST search. Uses beautiful soup
    to parse result.

    1. import packages
    2. Submit BLAST search with sequences
    3. Get result
    4. Parse MSA
    5. Return a tuple of e score, id of top match
    '''
    # 1. import packages
    import requests
    from bs4 import BeautifulSoup

    # 2. Submit BLAST search with sequences
    url = 'https://blast.ncbi.nlm.nih.gov/Blast.cgi'
    params = {'QUERY': seq, 'DATABASE': 'nr', 'PROGRAM': 'blastp', 'CMD': 'Put'}
    r = requests.post(url, data=params)

    # 3. Get result
    soup = BeautifulSoup(r.text, 'html.parser')
    result = soup.find('pre').text

    # 4. Parse MSA
    lines = result.split('\n')
    msa = []
    for line in lines:
        if line.startswith('>'):
            msa.append(line)

    # 5. Return a tuple of e score, id of top match
    e = float(msa[1].split()[-1])
    id = msa[0].split()[1]
    return e, id
e, id = blast('>seq1\n'
              'PNFYVPFSNATGVVRSPFEYPQYYLAEPWQFSMLAAYMFLLIVLGFPINFLTLYVTVQ')
result = float(e) < 1e-30

import requests
from bs4 import BeautifulSoup
import numpy as np

def blast(seq):
    '''
    Returns MSA with a BLAST search. Uses beautiful soup
    to parse result.

    1. import packages
    2. Submit BLAST search with sequences
    3. Get result
    4. Parse MSA
    5. Return a tuple of e score, id of top match
    '''
    # 1. import packages
    import requests
    from bs4 import BeautifulSoup

    # 2. Submit BLAST search with sequences
    url = 'https://blast.ncbi.nlm.nih.gov/Blast.cgi'
    params = {'QUERY': seq,
              'PROGRAM': 'blastn',
              'DATABASE': 'refseq_rna',
              'FILTER': 'L',
              'EXPECT': '10',
              'HITLIST_SIZE': '1',
              'ALIGNMENTS': '50',
              'DESCRIPTIONS': '50',
              'FORMAT_TYPE': 'HTML',
              'CLIENT': 'web',
              'SERVICE': 'plain',
              'NCBI_GI': 'on',
              'PAGE': 'Nucleotides',
              'CMD': 'Put'}
    r = requests.get(url, params=params)
    # 3. Get result
    soup = BeautifulSoup(r.text, 'html.parser')
    # 4. Parse MSA
    alignments = soup.find_all('pre')
    alignments = [x.text for x in alignments]
    alignments = [x.split('\n') for x in alignments]
    alignments = [x for x in alignments if len(x) > 1]
    alignments = [x for x in alignments if x[0].startswith('Query')]
    alignments = [x for x in alignments if x[1].startswith('Sbjct')]
    alignments = [x for x in alignments if len(x) > 2]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x for x in alignments if x[-1].startswith('Score')]
    alignments = [x
    return e, id
e, id = blast('>seq1\n'
              'PNFYVPFSNATGVVRSPFEYPQYYLAEPWQFSMLAAYMFLLIVLGFPINFLTLYVTVQ')
result = float(e) < 1e-30

import requests
from bs4 import BeautifulSoup
import numpy as np

def blast(seq):
    '''
    Returns MSA with a BLAST search. Uses beautiful soup
    to parse result.

    1. import packages
    2. Submit BLAST search with sequences
    3. Get result
    4. Parse MSA
    5. Return a tuple of e score, id of top match
    '''
    # 1.
    import requests
    from bs4 import BeautifulSoup

    # 2.
    url = 'https://blast.ncbi.nlm.nih.gov/Blast.cgi'
    params = {'PAGE': 'Nucleotides',
              'PROGRAM': 'blastn',
              'DATABASE': 'nr',
              'QUERY': seq,
              'CMD': 'Put'}
    r = requests.post(url, data=params)

    # 3.
    url = r.url.replace('Put', 'Get')
    r = requests.get(url)

    # 4.
    soup = BeautifulSoup(r.text, 'html.parser')
    msa = soup.find_all('pre')[0].text
    msa = msa.split('\n')

    # 5.
    e = msa[1].split()[-1]
    id = msa[0].split()[-1]

    return e, id
e, id = blast('>seq1\n'
              'PNFYVPFSNATGVVRSPFEYPQYYLAEPWQFSMLAAYMFLLIVLGFPINFLTLYVTVQ')
result = float(e) < 1e-30

import requests
from bs4 import BeautifulSoup
import numpy as np

def blast(seq):
    '''
    Returns MSA with a BLAST search. Uses beautiful soup
    to parse result.

    1. import packages
    2. Submit BLAST search with sequences
    3. Get result
    4. Parse MSA
    5. Return a tuple of e score, id of top match
    '''
    # 1. import packages
    import requests
    from bs4 import BeautifulSoup
    import numpy as np

    # 2. Submit BLAST search with sequences
    url = 'https://blast.ncbi.nlm.nih.gov/Blast.cgi'
    params = {'QUERY': seq, 'PROGRAM': 'blastp', 'DATABASE': 'nr', 'CMD': 'Put'}
    r = requests.post(url, data=params)

    # 3. Get result
    soup = BeautifulSoup(r.text, 'html.parser')
    res = soup.find_all('pre')[0].text.split('\n')

    # 4. Parse MSA
    msa = []
    for line in res:
        if line.startswith('>'):
            msa.append(line)
        elif line.startswith(' Score ='):
            e = float(line.split('=')[1].split('bits')[0].strip())
        elif line.startswith(' Identities ='):
            id = float(line.split('=')[1].split('/')[0].strip())

    # 5. Return a tuple of e score, id of top match
    return e, id
e, id = blast('>seq1\n'
              'PNFYVPFSNATGVVRSPFEYPQYYLAEPWQFSMLAAYMFLLIVLGFPINFLTLYVTVQ')
result = float(e) < 1e-30

import requests
from bs4 import BeautifulSoup
import numpy as np

def blast(seq):
    '''
    Returns MSA with a BLAST search. Uses beautiful soup
    to parse result.

    1. import packages
    2. Submit BLAST search with sequences
    3. Get result
    4. Parse MSA
    5. Return a tuple of e score, id of top match
    '''
    # 1.
    from Bio.Blast import NCBIWWW
    from Bio import SeqIO
    from Bio.Seq import Seq
    from Bio.SeqRecord import SeqRecord
    from Bio.Alphabet import IUPAC
    from Bio.Blast import NCBIXML
    import requests
    from bs4 import BeautifulSoup
    import numpy as np

    # 2.
    result_handle = NCBIWWW.qblast("blastp", "nr", seq)

    # 3.
    blast_records = NCBIXML.parse(result_handle)

    # 4.
    for blast_record in blast_records:
        for alignment in blast_record.alignments:
            for hsp in alignment.hsps:
                print('****Alignment****')
                print('sequence:', alignment.title)
                print('length:', alignment.length)
                print('e value:', hsp.expect)
                print(hsp.query[0:75] + '...')
                print(hsp.match[0:75] + '...')
                print(hsp.sbjct[0:75] + '...')

    # 5.
    e = hsp.expect
    id = alignment.title

    return e, id
e, id = blast('>seq1\n'
              'PNFYVPFSNATGVVRSPFEYPQYYLAEPWQFSMLAAYMFLLIVLGFPINFLTLYVTVQ')
result = float(e) < 1e-30

import math
import sys


def bravais_lattice(group_number):
    """
    Return bravais lattice name given space group number
    """
    [insert]
    return name

import math
import sys


def bravais_lattice(group_number):
    """
    Return bravais lattice name given space group number
    """
    name = None
    if group_number in range(1, 3):
        name = 'triclinic'
    elif group_number in range(3, 16):
        name = 'monoclinic'
    elif group_number in range(16, 75):
        name = 'orthorhombic'
    elif group_number in range(75, 143):
        name = 'tetragonal'
    elif group_number in range(143, 168):
        name = 'trigonal'
    elif group_number in range(168, 195):
        name = 'hexagonal'
    elif group_number in range(195, 231):
        name = 'cubic'
    else:
        sys.exit('Space group number out of range')
    return name
m = bravais_lattice(47)
result = m.lower() == 'orthorhombic'

import math
import sys


def bravais_lattice(group_number):
    """
    Return bravais lattice name given space group number
    """
    if group_number < 1 or group_number > 230:
        print("Invalid space group number")
        sys.exit()
    name = ""
    if group_number <= 2:
        name = "triclinic"
    elif group_number <= 15:
        name = "monoclinic"
    elif group_number <= 74:
        name = "orthorhombic"
    elif group_number <= 142:
        name = "tetragonal"
    elif group_number <= 167:
        name = "trigonal"
    elif group_number <= 194:
        name = "hexagonal"
    elif group_number <= 230:
        name = "cubic"
    return name
m = bravais_lattice(47)
result = m.lower() == 'orthorhombic'

import math
import sys


def bravais_lattice(group_number):
    """
    Return bravais lattice name given space group number
    """
    if group_number in range(1, 3):
        name = "triclinic"
    elif group_number in range(3, 16):
        name = "monoclinic"
    elif group_number in range(16, 75):
        name = "orthorhombic"
    elif group_number in range(75, 143):
        name = "tetragonal"
    elif group_number in range(143, 168):
        name = "trigonal"
    elif group_number in range(168, 195):
        name = "hexagonal"
    elif group_number in range(195, 231):
        name = "cubic"
    else:
        print("Space group number not recognized")
        sys.exit()

    return name
m = bravais_lattice(47)
result = m.lower() == 'orthorhombic'

import math
import sys


def bravais_lattice(group_number):
    """
    Return bravais lattice name given space group number
    """
    if group_number < 3:
        name = "triclinic"
    elif group_number < 16:
        name = "monoclinic"
    elif group_number < 75:
        name = "orthorhombic"
    elif group_number < 143:
        name = "tetragonal"
    elif group_number < 168:
        name = "trigonal"
    elif group_number < 195:
        name = "hexagonal"
    elif group_number < 231:
        name = "cubic"
    else:
        name = "unknown"

    return name
m = bravais_lattice(47)
result = m.lower() == 'orthorhombic'

import math
import sys


def bravais_lattice(group_number):
    """
    Return bravais lattice name given space group number
    """
    if group_number > 0 and group_number < 3:
        name = "triclinic"
    elif group_number > 2 and group_number < 16:
        name = "monoclinic"
    elif group_number > 15 and group_number < 75:
        name = "orthorhombic"
    elif group_number > 74 and group_number < 143:
        name = "tetragonal"
    elif group_number > 142 and group_number < 168:
        name = "trigonal"
    elif group_number > 167 and group_number < 195:
        name = "hexagonal"
    elif group_number > 194 and group_number < 231:
        name = "cubic"
    else:
        name = "unknown"

    return name
m = bravais_lattice(47)
result = m.lower() == 'orthorhombic'

import matplotlib.pyplot as plt
import rdkit
from rdkit import Chem
from rdkit.Chem import Draw
from rdkit.Chem import rdMolHash
from rdkit.Chem import rdMolDescriptors
from rdkit.Chem import Scaffolds
from rdkit.Chem import Crippen
from rdkit.Chem import Descriptors
from rdkit.ML.Descriptors import MoleculeDescriptors
from rdkit import DataStructs
from rdkit.Chem import Scaffolds
import numpy as np

def canonical(smiles_list):
    """
    Returns list of canonical forms of given molecules
    """
    [insert]
    return canon_list

import matplotlib.pyplot as plt
import rdkit
from rdkit import Chem
from rdkit.Chem import Draw
from rdkit.Chem import rdMolHash
from rdkit.Chem import rdMolDescriptors
from rdkit.Chem import Scaffolds
from rdkit.Chem import Crippen
from rdkit.Chem import Descriptors
from rdkit.ML.Descriptors import MoleculeDescriptors
from rdkit import DataStructs
from rdkit.Chem import Scaffolds
import numpy as np

def canonical(smiles_list):
    """
    Returns list of canonical forms of given molecules
    """
    canon_list = []
    for smiles in smiles_list:
        mol = Chem.MolFromSmiles(smiles)
        canon_list.append(Chem.MolToSmiles(mol, isomericSmiles=True))
    return canon_list
smiles = [
    'C1=CC=CN=C1',
    'c1cccnc1',
    'C([H])C'
]

ref_csmiles = [
    'c1ccncc1',
    'c1ccncc1',
    'CC'
]

csmiles = canonical(smiles)

print(csmiles)
print(ref_csmiles)

result = True
for r, c in zip(ref_csmiles, csmiles):
    result = result and r == c

import matplotlib.pyplot as plt
import rdkit
from rdkit import Chem
from rdkit.Chem import Draw
from rdkit.Chem import rdMolHash
from rdkit.Chem import rdMolDescriptors
from rdkit.Chem import Scaffolds
from rdkit.Chem import Crippen
from rdkit.Chem import Descriptors
from rdkit.ML.Descriptors import MoleculeDescriptors
from rdkit import DataStructs
from rdkit.Chem import Scaffolds
import numpy as np

def canonical(smiles_list):
    """
    Returns list of canonical forms of given molecules
    """
    canon_list = []
    for smiles in smiles_list:
        mol = Chem.MolFromSmiles(smiles)
        canon_list.append(Chem.MolToSmiles(mol))
    return canon_list
smiles = [
    'C1=CC=CN=C1',
    'c1cccnc1',
    'C([H])C'
]

ref_csmiles = [
    'c1ccncc1',
    'c1ccncc1',
    'CC'
]

csmiles = canonical(smiles)

print(csmiles)
print(ref_csmiles)

result = True
for r, c in zip(ref_csmiles, csmiles):
    result = result and r == c

import matplotlib.pyplot as plt
import rdkit
from rdkit import Chem
from rdkit.Chem import Draw
from rdkit.Chem import rdMolHash
from rdkit.Chem import rdMolDescriptors
from rdkit.Chem import Scaffolds
from rdkit.Chem import Crippen
from rdkit.Chem import Descriptors
from rdkit.ML.Descriptors import MoleculeDescriptors
from rdkit import DataStructs
from rdkit.Chem import Scaffolds
import numpy as np

def canonical(smiles_list):
    """
    Returns list of canonical forms of given molecules
    """
    canon_list = []
    for smiles in smiles_list:
        mol = Chem.MolFromSmiles(smiles)
        canon_list.append(Chem.MolToSmiles(mol, isomericSmiles=True))
    return canon_list
smiles = [
    'C1=CC=CN=C1',
    'c1cccnc1',
    'C([H])C'
]

ref_csmiles = [
    'c1ccncc1',
    'c1ccncc1',
    'CC'
]

csmiles = canonical(smiles)

print(csmiles)
print(ref_csmiles)

result = True
for r, c in zip(ref_csmiles, csmiles):
    result = result and r == c

import matplotlib.pyplot as plt
import rdkit
from rdkit import Chem
from rdkit.Chem import Draw
from rdkit.Chem import rdMolHash
from rdkit.Chem import rdMolDescriptors
from rdkit.Chem import Scaffolds
from rdkit.Chem import Crippen
from rdkit.Chem import Descriptors
from rdkit.ML.Descriptors import MoleculeDescriptors
from rdkit import DataStructs
from rdkit.Chem import Scaffolds
import numpy as np

def canonical(smiles_list):
    """
    Returns list of canonical forms of given molecules
    """
    canon_list = []
    for smiles in smiles_list:
        mol = Chem.MolFromSmiles(smiles)
        canon_list.append(Chem.MolToSmiles(mol, isomericSmiles=True))
    return canon_list
smiles = [
    'C1=CC=CN=C1',
    'c1cccnc1',
    'C([H])C'
]

ref_csmiles = [
    'c1ccncc1',
    'c1ccncc1',
    'CC'
]

csmiles = canonical(smiles)

print(csmiles)
print(ref_csmiles)

result = True
for r, c in zip(ref_csmiles, csmiles):
    result = result and r == c

import matplotlib.pyplot as plt
import rdkit
from rdkit import Chem
from rdkit.Chem import Draw
from rdkit.Chem import rdMolHash
from rdkit.Chem import rdMolDescriptors
from rdkit.Chem import Scaffolds
from rdkit.Chem import Crippen
from rdkit.Chem import Descriptors
from rdkit.ML.Descriptors import MoleculeDescriptors
from rdkit import DataStructs
from rdkit.Chem import Scaffolds
import numpy as np

def canonical(smiles_list):
    """
    Returns list of canonical forms of given molecules
    """
    canon_list = []
    for smiles in smiles_list:
        mol = Chem.MolFromSmiles(smiles)
        canon_list.append(Chem.MolToSmiles(mol))
    return canon_list
smiles = [
    'C1=CC=CN=C1',
    'c1cccnc1',
    'C([H])C'
]

ref_csmiles = [
    'c1ccncc1',
    'c1ccncc1',
    'CC'
]

csmiles = canonical(smiles)

print(csmiles)
print(ref_csmiles)

result = True
for r, c in zip(ref_csmiles, csmiles):
    result = result and r == c

import math
import sys

def carnot_efficiency(T_hot, T_cold):
   """
   This function returns the efficiency of a carnot efficiency operating between two temperatures
   """
   [insert]
   return eps

import math
import sys

def carnot_efficiency(T_hot, T_cold):
   """
   This function returns the efficiency of a carnot efficiency operating between two temperatures
   """
   eps = 1 - (T_cold/T_hot)
   return eps

import numpy as np

T_cold = 300
T_hot = 600

eps = 1 - T_cold/T_hot

eps_codex = carnot_efficiency(T_hot, T_cold)

# check 
if np.isclose(eps, eps_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def carnot_efficiency(T_hot, T_cold):
   """
   This function returns the efficiency of a carnot efficiency operating between two temperatures
   """
   eps = 1 - (T_cold/T_hot)
   return eps

import numpy as np

T_cold = 300
T_hot = 600

eps = 1 - T_cold/T_hot

eps_codex = carnot_efficiency(T_hot, T_cold)

# check 
if np.isclose(eps, eps_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def carnot_efficiency(T_hot, T_cold):
   """
   This function returns the efficiency of a carnot efficiency operating between two temperatures
   """
   eps = 1 - T_cold/T_hot
   return eps

import numpy as np

T_cold = 300
T_hot = 600

eps = 1 - T_cold/T_hot

eps_codex = carnot_efficiency(T_hot, T_cold)

# check 
if np.isclose(eps, eps_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def carnot_efficiency(T_hot, T_cold):
   """
   This function returns the efficiency of a carnot efficiency operating between two temperatures
   """
   eps = 1 - (T_cold/T_hot)
   return eps

import numpy as np

T_cold = 300
T_hot = 600

eps = 1 - T_cold/T_hot

eps_codex = carnot_efficiency(T_hot, T_cold)

# check 
if np.isclose(eps, eps_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def carnot_efficiency(T_hot, T_cold):
   """
   This function returns the efficiency of a carnot efficiency operating between two temperatures
   """
   eps = 1 - T_cold/T_hot
   return eps

import numpy as np

T_cold = 300
T_hot = 600

eps = 1 - T_cold/T_hot

eps_codex = carnot_efficiency(T_hot, T_cold)

# check 
if np.isclose(eps, eps_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def claussius(HVap, T1, P1, T2):
   """
   This function returns the phase transition pressure at temperature T2 given a heat of vaporization HVap, and and reference temperature and pressure T1 and P1
   """
   [insert]
   return P2

import math
import sys

def claussius(HVap, T1, P1, T2):
   """
   This function returns the phase transition pressure at temperature T2 given a heat of vaporization HVap, and and reference temperature and pressure T1 and P1
   """
   P2 = P1*math.exp((HVap/8.314)*(1/T1 - 1/T2))
   return P2

import numpy as np

# input
hvap = 5000 #J/mol
P1 = 1 # atm
R = 8.314 # 8.314 J/k mol
T1 = 300     # in K 
T2 = 350 

P2_codex = claussius(hvap, T1, P1, T2)
P2 = P1*np.exp(-hvap/R*(1/T2-1/T1))

# check 
if np.isclose(P2, P2_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def claussius(HVap, T1, P1, T2):
   """
   This function returns the phase transition pressure at temperature T2 given a heat of vaporization HVap, and and reference temperature and pressure T1 and P1
   """
   P2 = P1*math.exp(HVap*(1/T1 - 1/T2))
   return P2

import numpy as np

# input
hvap = 5000 #J/mol
P1 = 1 # atm
R = 8.314 # 8.314 J/k mol
T1 = 300     # in K 
T2 = 350 

P2_codex = claussius(hvap, T1, P1, T2)
P2 = P1*np.exp(-hvap/R*(1/T2-1/T1))

# check 
if np.isclose(P2, P2_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def claussius(HVap, T1, P1, T2):
   """
   This function returns the phase transition pressure at temperature T2 given a heat of vaporization HVap, and and reference temperature and pressure T1 and P1
   """
   P2 = P1*math.exp((HVap/8.314)*((1/T1)-(1/T2)))
   return P2

import numpy as np

# input
hvap = 5000 #J/mol
P1 = 1 # atm
R = 8.314 # 8.314 J/k mol
T1 = 300     # in K 
T2 = 350 

P2_codex = claussius(hvap, T1, P1, T2)
P2 = P1*np.exp(-hvap/R*(1/T2-1/T1))

# check 
if np.isclose(P2, P2_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def claussius(HVap, T1, P1, T2):
   """
   This function returns the phase transition pressure at temperature T2 given a heat of vaporization HVap, and and reference temperature and pressure T1 and P1
   """
   P2 = P1 * math.exp(HVap * (1/T1 - 1/T2))
   return P2

import numpy as np

# input
hvap = 5000 #J/mol
P1 = 1 # atm
R = 8.314 # 8.314 J/k mol
T1 = 300     # in K 
T2 = 350 

P2_codex = claussius(hvap, T1, P1, T2)
P2 = P1*np.exp(-hvap/R*(1/T2-1/T1))

# check 
if np.isclose(P2, P2_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def claussius(HVap, T1, P1, T2):
   """
   This function returns the phase transition pressure at temperature T2 given a heat of vaporization HVap, and and reference temperature and pressure T1 and P1
   """
   P2 = P1*math.exp((HVap*1000)/(8.314*T1)*(1/T2-1/T1))
   return P2

import numpy as np

# input
hvap = 5000 #J/mol
P1 = 1 # atm
R = 8.314 # 8.314 J/k mol
T1 = 300     # in K 
T2 = 350 

P2_codex = claussius(hvap, T1, P1, T2)
P2 = P1*np.exp(-hvap/R*(1/T2-1/T1))

# check 
if np.isclose(P2, P2_codex, rtol=0.01) == True:
    result = True 
else:
    result = False

import math
import sys

def compare_electronegativity(element1,element2):
   """
   This function returns True if element1 has a larger Pauling electronegativity than element2
   """
   import mendeleev
   [insert]
   return result

import math
import sys

def compare_electronegativity(element1,element2):
   """
   This function returns True if element1 has a larger Pauling electronegativity than element2
   """
   import mendeleev
   result = False
   if mendeleev.element(element1).electronegativity > mendeleev.element(element2).electronegativity:
      result = True
   return result
result = True if compare_electronegativity("O","C") else False

import math
import sys

def compare_electronegativity(element1,element2):
   """
   This function returns True if element1 has a larger Pauling electronegativity than element2
   """
   import mendeleev
   result = mendeleev.element(element1).electronegativity > mendeleev.element(element2).electronegativity
   return result
result = True if compare_electronegativity("O","C") else False

import math
import sys

def compare_electronegativity(element1,element2):
   """
   This function returns True if element1 has a larger Pauling electronegativity than element2
   """
   import mendeleev
   result = False
   e1 = mendeleev.element(element1)
   e2 = mendeleev.element(element2)
   if e1.electronegativity > e2.electronegativity:
      result = True
   return result


   return result
result = True if compare_electronegativity("O","C") else False

import math
import sys

def compare_electronegativity(element1,element2):
   """
   This function returns True if element1 has a larger Pauling electronegativity than element2
   """
   import mendeleev
   if element1 not in mendeleev.element or element2 not in mendeleev.element:
      print("Error: element not found")
      sys.exit()
   if mendeleev.element[element1].pauling_electronegativity > mendeleev.element[element2].pauling_electronegativity:
      result = True
   else:
      result = False
   return result
result = True if compare_electronegativity("O","C") else False

import math
import sys

def compare_electronegativity(element1,element2):
   """
   This function returns True if element1 has a larger Pauling electronegativity than element2
   """
   import mendeleev
   result = mendeleev.element(element1).electronegativity > mendeleev.element(element2).electronegativity
   return result
result = True if compare_electronegativity("O","C") else False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def condiff_1d(x):
  """
  This function computes the difference between consecutive elements in array x.
  """
  [insert]
  return diff

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def condiff_1d(x):
  """
  This function computes the difference between consecutive elements in array x.
  """
  diff = np.zeros(len(x)-1)
  for i in range(len(x)-1):
    diff[i] = x[i+1] - x[i]

  return diff
import numpy as np

x = np.array([1, 2, 4, 7, 0])

true_y = np.ediff1d(x)

pred_y = condiff_1d(x)

result = True if np.allclose(true_y,pred_y) else False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def condiff_1d(x):
  """
  This function computes the difference between consecutive elements in array x.
  """
  diff = np.zeros(x.shape)
  diff[1:] = x[1:] - x[:-1]
  return diff
import numpy as np

x = np.array([1, 2, 4, 7, 0])

true_y = np.ediff1d(x)

pred_y = condiff_1d(x)

result = True if np.allclose(true_y,pred_y) else False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def condiff_1d(x):
  """
  This function computes the difference between consecutive elements in array x.
  """
  diff = np.zeros(len(x)-1)
  for i in range(len(x)-1):
    diff[i] = x[i+1] - x[i]
  return diff
import numpy as np

x = np.array([1, 2, 4, 7, 0])

true_y = np.ediff1d(x)

pred_y = condiff_1d(x)

result = True if np.allclose(true_y,pred_y) else False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def condiff_1d(x):
  """
  This function computes the difference between consecutive elements in array x.
  """
  diff = np.zeros(len(x)-1)
  for i in range(len(x)-1):
    diff[i] = x[i+1] - x[i]
  return diff
import numpy as np

x = np.array([1, 2, 4, 7, 0])

true_y = np.ediff1d(x)

pred_y = condiff_1d(x)

result = True if np.allclose(true_y,pred_y) else False

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

def condiff_1d(x):
  """
  This function computes the difference between consecutive elements in array x.
  """
  diff = np.zeros(len(x)-1)
  for i in range(len(x)-1):
    diff[i] = x[i+1] - x[i]
  return diff
import numpy as np

x = np.array([1, 2, 4, 7, 0])

true_y = np.ediff1d(x)

pred_y = condiff_1d(x)

result = True if np.allclose(true_y,pred_y) else False

import math
import sys

def sum_of_cubes(n):
  """
  This function returns the sum of the first n cubes
  """
  [insert]
  return s

import math
import sys

def sum_of_cubes(n):
  """
  This function returns the sum of the first n cubes
  """
  s = 0
  for i in range(1, n+1):
    s += i**3
  return s
result = True if sum_of_cubes(5) == 225 else False

import math
import sys

def sum_of_cubes(n):
  """
  This function returns the sum of the first n cubes
  """
  s = 0
  for i in range(1, n+1):
    s += i**3
  return s
result = True if sum_of_cubes(5) == 225 else False

import math
import sys

def sum_of_cubes(n):
  """
  This function returns the sum of the first n cubes
  """
  s = 0
  for i in range(1, n+1):
    s += i**3
  return s
result = True if sum_of_cubes(5) == 225 else False

import math
import sys

def sum_of_cubes(n):
  """
  This function returns the sum of the first n cubes
  """
  s = 0
  for i in range(1, n+1):
    s += i**3
  return s
result = True if sum_of_cubes(5) == 225 else False

import math
import sys

def sum_of_cubes(n):
  """
  This function returns the sum of the first n cubes
  """
  s = 0
  for i in range(1, n+1):
    s += i**3
  return s
result = True if sum_of_cubes(5) == 225 else False

import math
import sys

def de_broglie(m,v):
   """
   This function returns the de Broglie wavelength for a particle of mass m with speed v.
   """
   [insert]
   return l

import math
import sys

def de_broglie(m,v):
   """
   This function returns the de Broglie wavelength for a particle of mass m with speed v.
   """
   h = 6.62606957e-34
   l = h/(m*v)
   return l
import numpy as np

# input params
h = 6.626e-34 
v = 1.00e6
m = 9.11e-31

lam  = h/(m*v)
print("lam =", lam)

lam_codex = de_broglie(m,v)

# check 
if np.isclose(lam, lam_codex) ==  True:
    result = True
else:
    result = False

import math
import sys

def de_broglie(m,v):
   """
   This function returns the de Broglie wavelength for a particle of mass m with speed v.
   """
   h = 6.626e-34
   l = h/(m*v)
   return l
import numpy as np

# input params
h = 6.626e-34 
v = 1.00e6
m = 9.11e-31

lam  = h/(m*v)
print("lam =", lam)

lam_codex = de_broglie(m,v)

# check 
if np.isclose(lam, lam_codex) ==  True:
    result = True
else:
    result = False